// File system implementation.  Five layers:
//   + Blocks: allocator for raw disk blocks.
//   + Log: crash recovery for multi-step updates.
//   + Files: inode allocator, reading, writing, metadata.
//   + Directories: inode with special contents (list of other inodes!)
//   + Names: paths like /usr/rtm/xv6/fs.c for convenient naming.
//
// This file contains the low-level file system manipulation
// routines.  The (higher-level) system call implementations
// are in sysfile.c.

#include "types.h"
#include "riscv.h"
#include "defs.h"
#include "param.h"
#include "stat.h"
#include "spinlock.h"
#include "proc.h"
#include "sleeplock.h"
#include "fs.h"
#include "buf.h"
#include "file.h"
#include "btree.h"

#define min(a, b) ((a) < (b) ? (a) : (b))
// there should be one superblock per disk device, but we run with
// only one device
struct superblock sb; 

// Read the super block.
static void
readsb(int dev, struct superblock *sb)
{
  struct buf *bp;

  bp = bread(dev, 1);
  memmove(sb, bp->data, sizeof(*sb));
  brelse(bp);
}

// Init fs
void
fsinit(int dev) {
  readsb(dev, &sb);
  if(sb.magic != FSMAGIC)
    panic("invalid file system");
  initlog(dev, &sb);
}

// Zero a block.
static void
bzero(int dev, int bno)
{
  struct buf *bp;

  bp = bread(dev, bno);
  memset(bp->data, 0, BSIZE);
  log_write(bp);
  brelse(bp);
}

// Blocks.

// Allocate a zeroed disk block.
static uint
balloc(uint dev)
{
  int b, bi, m;
  struct buf *bp;

  bp = 0;
  for(b = 0; b < sb.size; b += BPB){
    bp = bread(dev, BBLOCK(b, sb));
    for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
      m = 1 << (bi % 8);
      if((bp->data[bi/8] & m) == 0){  // Is block free?
        bp->data[bi/8] |= m;  // Mark block in use.
        log_write(bp);
        brelse(bp);
        bzero(dev, b + bi);
        return b + bi;
      }
    }
    brelse(bp);
  }
  panic("balloc: out of blocks");
}

// Free a disk block.
static void
bfree(int dev, uint b)
{
  struct buf *bp;
  int bi, m;

  bp = bread(dev, BBLOCK(b, sb));
  bi = b % BPB;
  m = 1 << (bi % 8);
  if((bp->data[bi/8] & m) == 0)
    panic("freeing free block");
  bp->data[bi/8] &= ~m;
  log_write(bp);
  brelse(bp);
}

// Inodes.
//
// An inode describes a single unnamed file.
// The inode disk structure holds metadata: the file's type,
// its size, the number of links referring to it, and the
// list of blocks holding the file's content.
//
// The inodes are laid out sequentially on disk at
// sb.startinode. Each inode has a number, indicating its
// position on the disk.
//
// The kernel keeps a cache of in-use inodes in memory
// to provide a place for synchronizing access
// to inodes used by multiple processes. The cached
// inodes include book-keeping information that is
// not stored on disk: ip->ref and ip->valid.
//
// An inode and its in-memory representation go through a
// sequence of states before they can be used by the
// rest of the file system code.
//
// * Allocation: an inode is allocated if its type (on disk)
//   is non-zero. ialloc() allocates, and iput() frees if
//   the reference and link counts have fallen to zero.
//
// * Referencing in cache: an entry in the inode cache
//   is free if ip->ref is zero. Otherwise ip->ref tracks
//   the number of in-memory pointers to the entry (open
//   files and current directories). iget() finds or
//   creates a cache entry and increments its ref; iput()
//   decrements ref.
//
// * Valid: the information (type, size, &c) in an inode
//   cache entry is only correct when ip->valid is 1.
//   ilock() reads the inode from
//   the disk and sets ip->valid, while iput() clears
//   ip->valid if ip->ref has fallen to zero.
//
// * Locked: file system code may only examine and modify
//   the information in an inode and its content if it
//   has first locked the inode.
//
// Thus a typical sequence is:
//   ip = iget(dev, inum)
//   ilock(ip)
//   ... examine and modify ip->xxx ...
//   iunlock(ip)
//   iput(ip)
//
// ilock() is separate from iget() so that system calls can
// get a long-term reference to an inode (as for an open file)
// and only lock it for short periods (e.g., in read()).
// The separation also helps avoid deadlock and races during
// pathname lookup. iget() increments ip->ref so that the inode
// stays cached and pointers to it remain valid.
//
// Many internal file system functions expect the caller to
// have locked the inodes involved; this lets callers create
// multi-step atomic operations.
//
// The icache.lock spin-lock protects the allocation of icache
// entries. Since ip->ref indicates whether an entry is free,
// and ip->dev and ip->inum indicate which i-node an entry
// holds, one must hold icache.lock while using any of those fields.
//
// An ip->lock sleep-lock protects all ip-> fields other than ref,
// dev, and inum.  One must hold ip->lock in order to
// read or write that inode's ip->valid, ip->size, ip->type, &c.

struct {
  struct spinlock lock;
  struct inode inode[NINODE];
} icache;

void
iinit()
{
  int i = 0;
  
  initlock(&icache.lock, "icache");
  for(i = 0; i < NINODE; i++) {
    initsleeplock(&icache.inode[i].lock, "inode");
  }
}

static struct inode* iget(uint dev, uint inum);

// Allocate an inode on device dev.
// Mark it as allocated by  giving it type type.
// Returns an unlocked but allocated and referenced inode.
struct inode*
ialloc(uint dev, char type)  // type类型修改
{
  int inum;
  struct buf *bp;
  struct dinode *dip;

  for(inum = 1; inum < sb.ninodes; inum++){
    bp = bread(dev, IBLOCK(inum, sb));
    dip = (struct dinode*)bp->data + inum%IPB;
    if(dip->type == 0){  // a free inode
      memset(dip, 0, sizeof(*dip));
      dip->type = type;
      dip->mode = 3;   // 初始化mode
      log_write(bp);   // mark it allocated on the disk
      brelse(bp);
      return iget(dev, inum);
    }
    brelse(bp);
  }
  panic("ialloc: no inodes");
}

// Copy a modified in-memory inode to disk.
// Must be called after every change to an ip->xxx field
// that lives on disk, since i-node cache is write-through.
// Caller must hold ip->lock.
void
iupdate(struct inode *ip)
{
  struct buf *bp;
  struct dinode *dip;

  bp = bread(ip->dev, IBLOCK(ip->inum, sb));
  dip = (struct dinode*)bp->data + ip->inum%IPB;
  dip->mode = ip->mode;   // 添加传递
  dip->type = ip->type;
  dip->major = ip->major;
  dip->minor = ip->minor;
  dip->nlink = ip->nlink;
  dip->size = ip->size;
  memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
  log_write(bp);
  brelse(bp);
}

// Find the inode with number inum on device dev
// and return the in-memory copy. Does not lock
// the inode and does not read it from disk.
static struct inode*
iget(uint dev, uint inum)
{
  struct inode *ip, *empty;

  acquire(&icache.lock);

  // Is the inode already cached?
  empty = 0;
  for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
    if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
      ip->ref++;
      release(&icache.lock);
      return ip;
    }
    if(empty == 0 && ip->ref == 0)    // Remember empty slot.
      empty = ip;
  }

  // Recycle an inode cache entry.
  if(empty == 0)
    panic("iget: no inodes");

  ip = empty;
  ip->dev = dev;
  ip->inum = inum;
  ip->ref = 1;
  ip->valid = 0;
  release(&icache.lock);

  return ip;
}

// Increment reference count for ip.
// Returns ip to enable ip = idup(ip1) idiom.
struct inode*
idup(struct inode *ip)
{
  acquire(&icache.lock);
  ip->ref++;
  release(&icache.lock);
  return ip;
}

// Lock the given inode.
// Reads the inode from disk if necessary.
void
ilock(struct inode *ip)
{
  struct buf *bp;
  struct dinode *dip;

  if(ip == 0 || ip->ref < 1)
    panic("ilock");

  acquiresleep(&ip->lock);

  if(ip->valid == 0){
    bp = bread(ip->dev, IBLOCK(ip->inum, sb));
    dip = (struct dinode*)bp->data + ip->inum%IPB;
    ip->mode = dip->mode;   // 添加传递
    ip->type = dip->type;
    ip->major = dip->major;
    ip->minor = dip->minor;
    ip->nlink = dip->nlink;
    ip->size = dip->size;
    memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
    brelse(bp);
    ip->valid = 1;
    if(ip->type == 0)
      panic("ilock: no type");
  }
}

// Unlock the given inode.
void
iunlock(struct inode *ip)
{
  if(ip == 0 || !holdingsleep(&ip->lock) || ip->ref < 1)
    panic("iunlock");

  releasesleep(&ip->lock);
}

// Drop a reference to an in-memory inode.
// If that was the last reference, the inode cache entry can
// be recycled.
// If that was the last reference and the inode has no links
// to it, free the inode (and its content) on disk.
// All calls to iput() must be inside a transaction in
// case it has to free the inode.
void
iput(struct inode *ip)
{
  acquire(&icache.lock);

  if(ip->ref == 1 && ip->valid && ip->nlink == 0){
    // inode has no links and no other references: truncate and free.

    // ip->ref == 1 means no other process can have ip locked,
    // so this acquiresleep() won't block (or deadlock).
    acquiresleep(&ip->lock);

    release(&icache.lock);

    itrunc(ip);
    ip->type = 0;
    iupdate(ip);
    ip->valid = 0;

    releasesleep(&ip->lock);

    acquire(&icache.lock);
  }

  ip->ref--;
  release(&icache.lock);
}

// Common idiom: unlock, then put.
void
iunlockput(struct inode *ip)
{
  iunlock(ip);
  iput(ip);
}

// Inode content
//
// The content (data) associated with each inode is stored
// in blocks on the disk. The first NDIRECT block numbers
// are listed in ip->addrs[].  The next NINDIRECT blocks are
// listed in block ip->addrs[NDIRECT].

// Return the disk block address of the nth block in inode ip.
// If there is no such block, bmap allocates one.
static uint
bmap(struct inode *ip, uint bn)
{
  uint addr, *a;
  struct buf *bp;

  if(bn < NDIRECT){
    if((addr = ip->addrs[bn]) == 0)
      ip->addrs[bn] = addr = balloc(ip->dev);
    return addr;
  }
  bn -= NDIRECT;

  if(bn < NINDIRECT){
    // Load indirect block, allocating if necessary.
    if((addr = ip->addrs[NDIRECT]) == 0)
      ip->addrs[NDIRECT] = addr = balloc(ip->dev);
    bp = bread(ip->dev, addr);
    a = (uint*)bp->data;
    if((addr = a[bn]) == 0){
      a[bn] = addr = balloc(ip->dev);
      log_write(bp);
    }
    brelse(bp);
    return addr;
  }

  bn -= NINDIRECT;
  if(bn < NDINDIRECT){
    // 二级间接索引的处理方法
    // 判断二级间接索引所在的位置是否有效
    if((addr = ip->addrs[NDIRECT + 1]) == 0)
      // 无效 分配一个空闲块作为二级索引页
      ip->addrs[NDIRECT + 1] = addr = balloc(ip->dev);
    // 使用缓冲区bp读出二级索引页
    bp = bread(ip->dev, addr);
    a = (uint*)bp->data;
    // 判断一级间接索引所在位置是否有效
    if((addr = a[bn / NINDIRECT]) == 0){
      // 无效 分配一个空闲块作为一级索引页
      a[bn / NINDIRECT] = addr = balloc(ip->dev);
      // 将修改后的buf写入日志
      log_write(bp);
    }
    // 释放buf缓冲区
    brelse(bp);
    // 使用缓冲区bp读出一级索引页
    bp = bread(ip->dev, addr);
    a = (uint*)bp->data;
    // 判断直接索引所在位置是否有效
    if((addr = a[bn % NINDIRECT]) == 0){
      // 无效 分配一个空闲块作为直接块
      a[bn % NINDIRECT] = addr = balloc(ip->dev);
      // 将修改后的buf写入日志
      log_write(bp);
    }
    // 释放buf缓冲区
    brelse(bp);
    // 返回找到的地址
    return addr;
  }

  panic("bmap: out of range");
}

// Truncate inode (discard contents).
// Caller must hold ip->lock.
void
itrunc(struct inode *ip)
{
  int i, j;
  struct buf *bp;
  uint *a;

  for(i = 0; i < NDIRECT; i++){
    if(ip->addrs[i]){
      bfree(ip->dev, ip->addrs[i]);
      ip->addrs[i] = 0;
    }
  }

  if(ip->addrs[NDIRECT]){
    bp = bread(ip->dev, ip->addrs[NDIRECT]);
    a = (uint*)bp->data;
    for(j = 0; j < NINDIRECT; j++){
      if(a[j])
        bfree(ip->dev, a[j]);
    }
    brelse(bp);
    bfree(ip->dev, ip->addrs[NDIRECT]);
    ip->addrs[NDIRECT] = 0;
  }

  // 二级间接索引是否有效
  if(ip->addrs[NDIRECT+1]){
    // 有效 释放二级间接索引
    // 使用buf读出二级索引页
    bp = bread(ip->dev, ip->addrs[NDIRECT + 1]);
    a = (uint*)bp->data;
    // 遍历二级索引页中的一级间接索引
    for(j = 0; j < NINDIRECT; j++){
      // 一级间接索引是否有效
      if(a[j]){
        // 有效 释放一级间接索引
        // 使用buf读出一级索引页
        // 注意：这里需要使用另一个buf
        struct buf *bp2 = bread(ip->dev, a[j]);
        uint *a2 = (uint*)bp2->data;
        int k;
        // 遍历一级索引页中的直接索引
        for(k = 0; k < NINDIRECT; k++){
          if(a2[k])
            // 释放直接索引
            bfree(ip->dev, a2[k]);
        }
        // 释放一级间接索引
        brelse(bp2);
        bfree(ip->dev, a[j]);
      }
    }
    // 释放二级间接索引
    brelse(bp);
    bfree(ip->dev, ip->addrs[NDIRECT + 1]);
    ip->addrs[NDIRECT + 1] = 0;
  }

  ip->size = 0;
  iupdate(ip);
}

// Copy stat information from inode.
// Caller must hold ip->lock.
void
stati(struct inode *ip, struct stat *st)
{
  st->dev = ip->dev;
  st->ino = ip->inum;
  st->mode = ip->mode;  // 添加传递
  st->type = ip->type;
  st->nlink = ip->nlink;
  st->size = ip->size;
}

// Read data from inode.
// Caller must hold ip->lock.
// If user_dst==1, then dst is a user virtual address;
// otherwise, dst is a kernel address.
int
readi(struct inode *ip, int user_dst, uint64 dst, uint off, uint n)
{
  uint tot, m;
  struct buf *bp;

  if(off > ip->size || off + n < off)
    return 0;
  if(off + n > ip->size)
    n = ip->size - off;

  for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
    bp = bread(ip->dev, bmap(ip, off/BSIZE));
    m = min(n - tot, BSIZE - off%BSIZE);
    if(either_copyout(user_dst, dst, bp->data + (off % BSIZE), m) == -1) {
      brelse(bp);
      tot = -1;
      break;
    }
    brelse(bp);
  }
  return tot;
}

// Write data to inode.
// Caller must hold ip->lock.
// If user_src==1, then src is a user virtual address;
// otherwise, src is a kernel address.
// Returns the number of bytes successfully written.
// If the return value is less than the requested n,
// there was an error of some kind.
int
writei(struct inode *ip, int user_src, uint64 src, uint off, uint n)
{
  uint tot, m;
  struct buf *bp;

  if(off > ip->size || off + n < off)
    return -1;
  if(off + n > MAXFILE*BSIZE)
    return -1;

  for(tot=0; tot<n; tot+=m, off+=m, src+=m){
    bp = bread(ip->dev, bmap(ip, off/BSIZE));
    m = min(n - tot, BSIZE - off%BSIZE);
    if(either_copyin(bp->data + (off % BSIZE), user_src, src, m) == -1) {
      brelse(bp);
      break;
    }
    log_write(bp);
    brelse(bp);
  }

  if(off > ip->size)
    ip->size = off;

  // write the i-node back to disk even if the size didn't change
  // because the loop above might have called bmap() and added a new
  // block to ip->addrs[].
  iupdate(ip);

  return tot;
}

// Directories

int
namecmp(const char *s, const char *t)
{
  return strncmp(s, t, DIRSIZ);
}

// 系统查找ip->dev所在的设备上的块号为block的块中存储的结构体
int
rbtn(struct inode *ip, int user_dst, uint64 dst, int n, int block)
{
  struct buf *bp;
  bp = bread(ip->dev, block);
  if(either_copyout(user_dst, dst, bp->data, sizeof(struct btreenode)) == -1) {
    brelse(bp); // 释放缓冲区
    return -1;  // 设置错误标志
  }
  // 释放缓冲区（注意：在成功复制数据后应立即释放，以避免内存泄漏）
  brelse(bp);
  return sizeof(struct btreenode);
}

// 申请一个btreenode节点
void
btnalloc(struct btreenode *btn, struct inode *ip) 
{
  btn->isleaf = 1;
  btn->numkeys = 0;
  btn->childnum = 0;
  // 分配一个空闲块
  btn->block = balloc(ip->dev);
  // 将孩子节点的指针都设为 block 0，即无效状态
  for(int i = 0; i < MAXBTN + 1; i++){
      btn->children[i] = 0;
  }
}

// 根据name找到应该插入的B树节点，并存储查找的路径
int
btnfind(struct btreenode *btn, struct inode *ip, struct btreetable *btt, char *name){
  struct buf *bp;
  // B树根节点所在块号
  uint blocknum = ip->addrs[0];

  // 找不到该目录的btree根结点，分配一个空块存储根节点
  if(blocknum == 0){
    btnalloc(btn, ip);
    ip->addrs[0] = btn->block;
    ip->size = sizeof(struct btreenode);
    btt->btstack[btt->stacktop++] = btn->block;
    iupdate(ip);
    return 0;
  }
  while(1){
    // 根据块号找结点
    bp = bread(ip->dev, blocknum);
    memmove(btn, bp->data, sizeof(struct btreenode));
    brelse(bp);
    // 维护路径栈和栈顶指针
    btt->btstack[btt->stacktop++] = blocknum; 
    // 找到叶子节点，成功返回
    if(btn->isleaf) return 0;
    // 不是叶子节点，则继续寻找
    int i = 0;
    for(; i < btn->numkeys; i++){
      int res = namecmp(name, btn->keys[i].name);
      if(res == 0){       // name == keys[i].name
        return -1;        // 存在同名目录项，失败返回
      }else if(res < 0){  // name < b.keys[i].name
        blocknum = btn->children[i];
        break;            // 继续寻找对应的子节点
      }
    }
    // 继续寻找对应的子节点
    if(i == btn->numkeys) blocknum = btn->children[i];
  }
  return -1;
}

// 查找此目录项在此B树节点的目标存放位置
int
findsuiteindex(struct btreenode *btn, struct dirent *de) 
{
  int index;
  for (index = 0; index < btn->numkeys; index++) {
    if (namecmp(de->name, btn->keys[index].name) < 0)
      break;
  }
  return index;
}

struct btreenode newbtn;
struct btreenode parentbtn;
// 将此目录项插入对应的B树叶节点
int
btninsert(struct btreenode *lbtn, struct inode *ip, struct btreetable *btt, struct dirent *de, int index) 
{
	int i = 0;
  struct buf *bp;
  // 腾出需要添加的目录项的位置
  for (i = lbtn->numkeys; i > index; i--) 
    lbtn->keys[i] = lbtn->keys[i-1];
  lbtn->keys[index] = *de;
  lbtn->numkeys++;
  // 超过最大关键数
  if ( lbtn->numkeys == MAXBTN ) {
	  int mid = 0;
    // 找到中间位置
    mid = MAXBTN / 2 + MAXBTN % 2 - 1;
    // 节点开始分裂:lbtn + rbtn
    struct btreenode rbtn;
    btnalloc(&rbtn, ip);
    rbtn.isleaf = lbtn->isleaf;
    // 将mid右边的键赋值给rbtn，并将lbtn对应位置清空
    for (i = mid + 1; i < lbtn->numkeys; i++) {
      rbtn.keys[i - mid - 1] = lbtn->keys[i];
      lbtn->keys[i].inum = 0;
      memset(lbtn->keys[i].name, 0, DIRSIZ);
      rbtn.numkeys++;
    }
    // 将mid右边的孩子赋值给rbtn的孩子，并将lbtn对应位置清空
    for (i = mid + 1; i < lbtn->childnum; i++) {
      rbtn.children[i - mid - 1] = lbtn->children[i];
      lbtn->children[i] = 0;
      rbtn.childnum++;
    }
    // 设置分裂后的lbtn
    if(lbtn->childnum > (mid + 1)) lbtn->childnum = mid + 1;
    lbtn->numkeys = mid;
    // 判断当前节点是不是根节点
    if (btt->btstack[0] == lbtn->block) {
      // 是根节点，重新构造根节点
      // struct btreenode newbtn;
      btnalloc(&newbtn, ip);
      newbtn.isleaf = 0;
      newbtn.keys[0] = lbtn->keys[mid];
      newbtn.numkeys++;
      newbtn.children[0] = lbtn->block;
      newbtn.children[1] = rbtn.block;
      newbtn.childnum = 2;
      ip->addrs[0] = newbtn.block;
      // 将更新后的inode和分裂后的B树节点写回磁盘
      iupdate(ip);
      bp = bread(ip->dev, newbtn.block);
      if(either_copyin(bp->data, 0, (uint64)&newbtn, sizeof(struct btreenode)) == -1) {
        brelse(bp);
        return -1;
      }
      log_write(bp);
      brelse(bp);
      bp = bread(ip->dev, rbtn.block);
      if(either_copyin(bp->data, 0, (uint64)&rbtn, sizeof(struct btreenode)) == -1) {
        brelse(bp);
        return -1;
      }
      log_write(bp);
      brelse(bp);
      bp = bread(ip->dev, lbtn->block);
      if(either_copyin(bp->data, 0, (uint64)lbtn, sizeof(struct btreenode)) == -1) {
        brelse(bp);
        return -1;
      }
      log_write(bp);
      brelse(bp);
      return 0;
    }
    else {
      // 不是根节点，将需要提升的键插入父节点
      bp = bread(ip->dev, rbtn.block);
      if(either_copyin(bp->data, 0, (uint64)&rbtn, sizeof(struct btreenode)) == -1) {
        brelse(bp);
        return -1;
      }
      log_write(bp);
      brelse(bp);
      bp = bread(ip->dev, lbtn->block);
      if(either_copyin(bp->data, 0, (uint64)lbtn, sizeof(struct btreenode)) == -1) {
        brelse(bp);
        return -1;
      }
      log_write(bp);
      brelse(bp);
      // 先将需要上传的目录项保存，在递归中parentbtn和lbtn是同一个地址，lbtn被覆盖
      *de = lbtn->keys[mid];
      // struct btreenode parentbtn;
      // 根据路径栈可以找到父节点所在块号，将其读出
      bp = bread(ip->dev, btt->btstack[--btt->stacktop]);
      memmove(&parentbtn, bp->data, sizeof(struct btreenode));
      brelse(bp);
      // 找到在父节点处应该的插入位置，处理父节点的子节点
      index = findsuiteindex(&parentbtn, de);
      if (parentbtn.children[index + 1] != 0) {
        for (i = parentbtn.numkeys; i > index; i--) {
          parentbtn.children[i + 1] = parentbtn.children[i];
        }
      }
      parentbtn.children[index + 1] = rbtn.block;
      parentbtn.childnum++;
      btninsert(&parentbtn, ip, btt, de, index);
    }
  }else{
    bp = bread(ip->dev, lbtn->block);
    if(either_copyin(bp->data, 0, (uint64)lbtn, sizeof(struct btreenode)) == -1) {
      brelse(bp);
      return -1;
    }
    log_write(bp);
    brelse(bp);
  }
  return 0;
}

// Look for a directory entry in a directory.
// If found, set *poff to byte offset of entry.
struct inode*
dirlookup(struct inode *dp, char *name, uint *poff)
{
  // uint off, inum;
  // struct dirent de;

  // if(dp->type != T_DIR)
  //   panic("dirlookup not DIR");

  // for(off = 0; off < dp->size; off += sizeof(de)){
  //   if(readi(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
  //     panic("dirlookup read");
  //   if(de.inum == 0)
  //     continue;
  //   if(namecmp(name, de.name) == 0){
  //     // entry matches path element
  //     if(poff)
  //       *poff = off;
  //     inum = de.inum;
  //     return iget(dp->dev, inum);
  //   }
  // }
  // 根据name在dp的B树中查找对应的目录项
  uint blocknum;
  struct btreenode btn;
  struct buf *bp;
  // B树根节点所在块号
  blocknum = dp->addrs[0];
  // 找不到该目录的btree根结点
  if(blocknum == 0){
    return 0;
  }
  while(1){
    // 根据块号找结点
    bp = bread(dp->dev, blocknum);
    memmove(&btn, bp->data, sizeof(struct btreenode));
    brelse(bp);
    // 在这个节点中比较
    int i = 0;
    for(; i < btn.numkeys; i++){
      int res = namecmp(name, btn.keys[i].name);
      if(res == 0){                             // name == keys[i].name
        return iget(dp->dev, btn.keys[i].inum); // 成功找到对应目录项
      }else if(res < 0){                        // name < b.keys[i].name
        blocknum = btn.children[i];
        break;                                  // 继续寻找对应的子节点
      }
    }
    // 找到叶子节点，无子节点，失败返回
    if(btn.isleaf) return 0;
    // 继续寻找对应的子节点
    if(i == btn.numkeys) blocknum = btn.children[i];
  }

  return 0;
}

// Write a new directory entry (name, inum) into the directory dp.
int
dirlink(struct inode *dp, char *name, uint inum)
{
  // int off;
  // struct dirent de;
  // struct inode *ip;

  // // Check that name is not present.
  // if((ip = dirlookup(dp, name, 0)) != 0){
  //   iput(ip);
  //   return -1;
  // }

  // // Look for an empty dirent.
  // for(off = 0; off < dp->size; off += sizeof(de)){
  //   if(readi(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
  //     panic("dirlink read");
  //   if(de.inum == 0)
  //     break;
  // }

  // strncpy(de.name, name, DIRSIZ);
  // de.inum = inum;
  // if(writei(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
  //   panic("dirlink");

  // return 0;
  // 根据name和inum构建一个目录项，将其插入dp的B树中
  struct btreenode btn;
  struct btreetable btt;
  struct dirent de;
  // 初始化路径栈
  for(int i = 0; i < NBTN; i++) btt.btstack[i] = 0;
  btt.stacktop = 0;
  // 创建设置目录项
  de.inum = inum;
  strncpy(de.name, name, DIRSIZ);
  // 寻找目录项应该插入的btn
  if(btnfind(&btn, dp, &btt, name) < 0) {
    return -1;
  }
  // 使栈顶指针指向当前btn
  if(btt.stacktop != 0)btt.stacktop--;
  // 将目录项插入当前btn
  btninsert(&btn, dp, &btt, &de, findsuiteindex(&btn, &de));
  return 0;
}

// Is the directory dp empty except for "." and ".." ?
static int
isdirempty(struct inode *dp)
{
  // int off;
  // struct dirent de;

  // for(off=2*sizeof(de); off<dp->size; off+=sizeof(de)){
  //   if(readi(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
  //     panic("isdirempty: readi");
  //   if(de.inum != 0)
  //     return 0;
  // }
  struct buf *bp;
  uint blocknum;
  struct btreenode btn;
  // B树根节点所在块号
  blocknum = dp->addrs[0];
  // 找不到该目录的btree根结点
  if(blocknum == 0){
    return 0;
  }
  bp = bread(dp->dev, blocknum);
  memmove(&btn, bp->data, sizeof(struct btreenode));
  brelse(bp);
  if(btn.numkeys == 2 && btn.isleaf)
    return 1;
  return 0;
}

// Look for a directory entry in a directory.
// If found, delete this directory.
struct inode*
dirdel(struct inode *dp, char *name)
{
  // 根据name在dp的B树中查找对应的目录项
  uint blocknum;
  struct btreenode btn,lrbtn;
  struct buf *bp;
  struct inode *ip;
  // B树根节点所在块号
  blocknum = dp->addrs[0];
  // 找不到该目录的btree根结点
  if(blocknum == 0){
    return 0;
  }
  while(1){
    // 根据块号找结点
    bp = bread(dp->dev, blocknum);
    memmove(&btn, bp->data, sizeof(struct btreenode));
    brelse(bp);
    // 在这个节点中比较
    int i = 0;
    for(; i < btn.numkeys; i++){
      int res = namecmp(name, btn.keys[i].name);
      if(res == 0){                             // name == keys[i].name
        ip = iget(dp->dev, btn.keys[i].inum);   // 成功找到对应目录项
        if(ip  == 0) return 0;
        ilock(ip);
        if(ip->nlink < 1)
          panic("unlink: nlink < 1");
        if(ip->type == T_DIR && !isdirempty(ip)){
          iunlockput(ip);
          return 0;
        }
        // 删除节点
        if(btn.isleaf){ // 终端节点
          int j = 0;
          for (j = i; j < btn.numkeys - 1; j++) 
            btn.keys[j] = btn.keys[j+1];
          btn.numkeys--;
        }else{ // 非终端节点
          // 找直接前驱
          bp = bread(dp->dev, btn.children[i]);
          memmove(&lrbtn, bp->data, sizeof(struct btreenode));
          brelse(bp);
          // 借前驱
          btn.keys[i].inum = lrbtn.keys[lrbtn.numkeys - 1].inum;
          strncpy(btn.keys[i].name, lrbtn.keys[lrbtn.numkeys - 1].name, DIRSIZ);
          lrbtn.numkeys--;
          // 更新前驱
          bp = bread(ip->dev, lrbtn.block);
          if(either_copyin(bp->data, 0, (uint64)&lrbtn, sizeof(struct btreenode)) == -1) {
            brelse(bp);
            return 0;
          }
          log_write(bp);
          brelse(bp);
        }
        // 更新节点
        bp = bread(ip->dev, btn.block);
        if(either_copyin(bp->data, 0, (uint64)&btn, sizeof(struct btreenode)) == -1) {
          brelse(bp);
          return 0;
        }
        log_write(bp);
        brelse(bp);
        return ip;
      }else if(res < 0){                        // name < b.keys[i].name
        blocknum = btn.children[i];
        break;                                  // 继续寻找对应的子节点
      }
    }
    // 找到叶子节点，无子节点，失败返回
    if(btn.isleaf) return 0;
    // 继续寻找对应的子节点
    if(i == btn.numkeys) blocknum = btn.children[i];
  }

  return 0;
}

// Paths

// Copy the next path element from path into name.
// Return a pointer to the element following the copied one.
// The returned path has no leading slashes,
// so the caller can check *path=='\0' to see if the name is the last one.
// If no name to remove, return 0.
//
// Examples:
//   skipelem("a/bb/c", name) = "bb/c", setting name = "a"
//   skipelem("///a//bb", name) = "bb", setting name = "a"
//   skipelem("a", name) = "", setting name = "a"
//   skipelem("", name) = skipelem("////", name) = 0
//
static char*
skipelem(char *path, char *name)
{
  char *s;
  int len;

  while(*path == '/')
    path++;
  if(*path == 0)
    return 0;
  s = path;
  while(*path != '/' && *path != 0)
    path++;
  len = path - s;
  if(len >= DIRSIZ)
    memmove(name, s, DIRSIZ);
  else {
    memmove(name, s, len);
    name[len] = 0;
  }
  while(*path == '/')
    path++;
  return path;
}

// Look up and return the inode for a path name.
// If parent != 0, return the inode for the parent and copy the final
// path element into name, which must have room for DIRSIZ bytes.
// Must be called inside a transaction since it calls iput().
static struct inode*
namex(char *path, int nameiparent, char *name)
{
  struct inode *ip, *next;

  if(*path == '/')
    ip = iget(ROOTDEV, ROOTINO);
  else
    ip = idup(myproc()->cwd);

  while((path = skipelem(path, name)) != 0){
    ilock(ip);
    if(ip->type != T_DIR){
      iunlockput(ip);
      return 0;
    }
    if(nameiparent && *path == '\0'){
      // Stop one level early.
      iunlock(ip);
      return ip;
    }
    if((next = dirlookup(ip, name, 0)) == 0){
      iunlockput(ip);
      return 0;
    }
    iunlockput(ip);
    ip = next;
  }
  if(nameiparent){
    iput(ip);
    return 0;
  }
  return ip;
}

struct inode*
namei(char *path)
{
  char name[DIRSIZ];
  return namex(path, 0, name);
}

struct inode*
nameiparent(char *path, char *name)
{
  return namex(path, 1, name);
}
